TrustRadius Insights
Apache Camel is widely used as an enterprise integration solution by organizations transitioning from a monolithic to a service-oriented …
Overview
What is Apache Camel?
Apache Camel is an open source integration platform.
Recent Reviews
Pricing
Entry-level set up fee?
- No setup fee
Offerings
- Free Trial
- Free/Freemium Version
- Premium Consulting/Integration Services
Would you like us to let the vendor know that you want pricing?
10 people also want pricing
Alternatives Pricing
What is Cin7?
Cin7, headqduartered in Auckland, aims to make complex retail and wholesale simple with all-in-one cloud inventory, POS, EDI and 3PL. Cin7 allows users to manage sales channels, inventory, point of sale and supply chain in one central, cloud-based software. Cin7 offers integrations using third…
Product Details
- About
- Tech Details
What is Apache Camel?
Apache Camel Technical Details
| Operating Systems | Unspecified |
|---|---|
| Mobile Application | No |
Comparisons
Compare with
Reviews and Ratings
(34)
Community Insights
TrustRadius Insights are summaries of user sentiment data from TrustRadius reviews and, when necessary, 3rd-party data sources. Have feedback on this content? Let us know!
- Business Problems Solved
- Pros
- Cons
- Recommendations
Apache Camel is widely used as an enterprise integration solution by organizations transitioning from a monolithic to a service-oriented architecture. Its lightweight nature, ease of use, and implementation of existing integration patterns make it a popular choice. Users praise Apache Camel for its groovy DSL, which simplifies the process of connecting microservices and enabling the publish-subscribe pattern by consuming from and producing to AWS SQS queues.
Quartz jobs heavily rely on Apache Camel for seamless integration, and Cox Communications utilizes this product in various departments to provide quick and scalable integration of diverse business systems. By reducing development effort and resources, Apache Camel fits well within Cox's existing infrastructure and is often used alongside customized versions of Camel components. In product development teams, Apache Camel is essential for core event processing, facilitating interactions over JMS between different modules while handling marshaling, unmarshaling, and sending/receiving POJOs.
With its plethora of plugins for various connectors and a user-friendly experience, Apache Camel serves as an alternative integration framework to heavier middleware solutions. It acts as a component of an Enterprise Service Bus, defining message routing and transformation rules for integrating on-premise applications and cloud services. Moreover, Apache Camel bridges systems with changing implementations and message formats, enabling seamless integration and workflow pipelines. Teams appreciate the time-saving and scalable nature of this product, making it a preferred choice in multiple organizations for EIP and event-based code projects. Lastly, Apache Camel proves to be vital as an integration layer between UI, backend services, and databases using its REST component and XML/Java DSL solutions.
The open-source nature of Apache Camel particularly shines when performing daily integration activities in non-production environments. It offers a reliable platform for deriving code from files based on defined logic and processes. Additionally, Apache Camel handles error handling with built-in features like error retry, waiting, and exponential backoff. This makes it the go-to choice for integrating multiple sources and sinks of data with different formats and protocols, allowing for the implementation of complex logic. Overall, Apache Camel is highly regarded for its ability to simplify integration activities and enable seamless connectivity across various systems and platforms.
Easy Learning Curve: Several users have found Apache Camel to have an easy learning curve, allowing them to quickly grasp the concepts and start using it efficiently.
Extensive Integration Support: Many reviewers have praised Apache Camel for its extensive support for integration with diverse software platforms. With over 150 components available, users can seamlessly integrate Camel with various frameworks and middleware products such as Spring, Apache Karaf, and Servicemix.
Robustness and Reliability: Numerous users have highlighted the robustness of Apache Camel in handling various information transfer protocols out-of-the-box. They appreciate that it is a reliable solution for their integration needs, making it suitable for creating microservices and handling complex business logic.
Lack of Detail in Documentation: Several users have found the documentation to be lacking in detail and feel that it could use improvement. They mention that sometimes it takes trial and error to figure out how to do something, indicating a need for more comprehensive instructions.
Steep Learning Curve: Users have mentioned that there is a relatively steep learning curve associated with using the software. Some users felt overwhelmed by the complexity and required a significant amount of time and effort to become proficient in its usage.
Dependence on Java Skills: A common concern expressed by users is the heavy dependence on Java skills for optimal use of the software. Many users feel that a great skill set in Java is required to effectively utilize all the features and capabilities offered by the software.
Users have praised Apache Camel as an excellent choice for beginners in integration software development. They have found it to be user-friendly and valuable when starting out in this field. Reviewers also recommend utilizing online videos for additional assistance with Apache Camel. Video tutorials offer helpful insights and explanations. Another common recommendation is to consider Apache Camel as a viable alternative to larger middleware options like IBM. Users appreciate its flexibility and simplicity compared to more complex and expensive alternatives. It is also advised to have a clear understanding of EIPS (Enterprise Integration Patterns) when using Apache Camel. Additionally, users suggest keeping routes small and limiting the number of threads on endpoints to prevent idle threads from consuming locks.
Reviews
(1-5 of 5)Companies can't remove reviews or game the system. Here's why
July 25, 2022
Apache Camel - Integrate lots of things together with custom complex business logic on top
We had some workloads where we need to integrate multiple sources & sinks of data, with different formats & protocols, while doing some pretty complex logic on top of that. Apache Camel was a natural choice for it since there are tons of built-in components that allow making easy connections to all the sources & sinks that we need. On the other hand, the Java-native nature of Apache Camel means writing & testing whatever logic we need is just business-as-usual for the engineers.
- Easy & reliable integration with lots of types of source or sink of data.
- Complex business logic could be written in Java.
- Excellent unit testing support with Java.
- Documentation could be improved
- Support for complex & advance integration options could be better
- Navigating the Java code base requires learning curve
- Built-in components
- Java-native nature
- Configuration-as-code
- We got all diverse sources & sinks integrated.
- We got our complex business logic implemented.
- All things checked in to SCM & unit-tested.
June 23, 2022
Routing made simple!
We use Apache Camel as a bridge between various systems, where implementation and message format is changing fairly often. Integration and tasks workflow pipeline. This system allows for fast and scale able integrations and deployment. This has saved us man time and power.
- Adding new routes is very easy and efficient
- Easy to use, easy to get up and running
- Great integration with java frameworks
- The documentation is a little deficient
- Lacking a framework integration with big data capabilities
- Ease of use
- Lightweight
- XML and Java based configuration is supported.
- The routing engine is superb
- Very lightweight and basic tool
- Does not allow for greater customization
Easier to use, better routing system, but perhaps too basic dependant on business needs?
March 28, 2017
best lightweight integration solution
When we switched from a monolithic architecture to a service oriented one we were researching on all the enterprise integration technologies. We chose Apache Camel because it was lightweight, was easy to get started with, had a groovy DSL and because it was an implementation of existing integration patterns. Over the last few years, Apache Camel became the glue that binds all our micro services. We use publish-subscribe pattern the most i.e consuming from and producing to AWS SQS queues. A lot of our quartz jobs are heavily depended on Apache Camel as well. I would highly recommend Apache Camel as a lightweight yet formidable enterprise integration solution.
- Producing to and consuming from any messaging system
- Message type conversion
- Large support library
- Documentation could use some more detail
- Hot deployment
- When we were looking to move to a service oriented architecture, Apache Camel got us started quickly. It continues to be the backbone of our integration.
We chose Apache Camel because it was lightweight, easy to get started with and because it had a groovy DSL since we were a grails shop when we started using it.
July 15, 2016
Better on a Camel
Apache Camel is used by many departments at Cox Communications, but not the entire organization. It enables quick and scaleable integration of diverse business systems at Cox and reduces development effort and resources. Various Camel components are used and there is even a customized version of Camel Http4 component. Also Camel fits well in the existing infrastructure at Cox.
- Camel has an easy learning curve. It is fairly well documented and there are about 5-6 books on Camel.
- There is a large user group and blogs devoted to all things Camel and the developers of Camel provide quick answers and have also been very quick to patch Camel, when bugs are reported.
- Camel integrates well with well known frameworks like Spring, and other middleware products like Apache Karaf and Servicemix.
- There are over 150 components for the Camel framework that help integrate with diverse software platforms.
- Camel is also good for creating microservices.
- Camel features and documentation can get confusing to new users. Documentation can and should be improved. Also it would help if there are more tutorials available. Certification in Camel and related technologies like Servicemix and Karaf would also help.
- The Camel infrastructure probably needs to be rebuilt (hopefully this may happen with version 3.0). At this time the latest production release of Camel (2.17.x) is not built with the latest version of Java (JDK 1.8).
- Camel should also move towards becoming a "heavyweight" ESB product, though this may detract from some of its desirable features.
- This is hard to guage, but definitely the effort and resources required to develop and deploy new applications has gone down considerably. Approximately 50-70% lesser resources compared to the traditional way of developing applications.
- Code complexity and maintenance costs have gone down, again over 50%.
- Unit testing has cut down on bugs in production. There are far fewer bugs than would have been the case with plain Java. Approximately 70% less bugs discovered.
- Camel is a free, open source product. It is free as opposed to similar proprietary products like Tibco Business Works.
Apache Camel has been the integration framework of choice, but I was not the person to make the decision to use it. Compared to other competing products like Tibco Business Works, etc., it is free and open source and its licensing policy is acceptable to the management of Cox.
I worked on a product development team creating an enterprise cybersecurity product. The core event processing mechanism of the product used Apache Camel in many places, mainly to handle interactions over JMS between the various modules of the product. Apache Camel especially makes the process of sending a POJO from one method to another across two separate application components, handling the marshaling and unmarshaling via JAXB, and the sending and receiving via JMS. It achieves all this routing via a simple XML configuration that is part of the application's spring context (although it can also be configured procedurally).
- Configuration of information routing via XML in a Sprint Context.
- Robustness. Apache Camel is capable of handling many different information transfer protocols out-of-the-box.
- Extensibility. Apache Camel also allows for custom routing handlers where needed.
- Some of the documentation is a little sparse. In particular, its TCP-based routes use an underlying Netty server, and the interactions between Netty's decoder capabilities and Apache Camel's routing/handler capabilities can be a little muddy at times. In general it is clear which routes and endpoints are the more frequently used and which haven't been given as much attention.
- There was certainly a positive impact in terms of code maintainability and ease of implementing new messaging pipelines, however, it's a little difficult to quantify.
Esper is only similar in that they both are involved in complex even processing, however Esper's aim is a little more complex and specialized. In general however I found Apache Camel to be much easier to understand, implement and debug, whereas Esper's DSL can get very complicated and hard to debug and test. When done correctly however, Esper offers much more analytical capabilities for correlating and reasoning about asynchronous events.